def validate_config(self, config):
    if not isinstance(config, dict):
        raise errors.BmcGoException(f"{self.config_key}配置必须是字典类型")
    
    if 'work_path' not in config:
        raise errors.BmcGoException(f"{self.config_key}缺少必需字段: work_path")
    
    # download字段验证
    if label != 'local' and 'download' in config:
        if not isinstance(config['download'], list) or len(config['download']) == 0:
            raise errors.BmcGoException(f"{self.config_key}.download必须是非空列表")
        for i, item in enumerate(config['download']):
            if 'sha256sum' in item:
                if not isinstance(sha256sum, str) or len(sha256sum) != 64:
                    raise errors.BmcGoException(f"sha256sum必须是64位的SHA256哈希值")
    
    # install.mode验证
    if mode not in ['default', 'oee', 'custom']:
        raise errors.BmcGoException(f"install.mode必须是default、oee或custom")

class CustomBuildToolsInstaller(CustomInstaller):
    """构建工具安装器"""
    
    def __init__(self, config, work_name=""):
        super(CustomBuildToolsInstaller, self).__init__(config, "build_tool", work_name)
    
    def execute_specified_install(self, install_path):
        """执行OEE安装逻辑"""
        work_path = self.install_config.get('work_path')
        os.chdir(work_path)
        
        # 清除LD_LIBRARY_PATH避免库冲突
        if 'LD_LIBRARY_PATH' in os.environ:
            del os.environ['LD_LIBRARY_PATH']
        
        # 执行OEE工具链安装脚本
        install_script = "openeuler-x86_64-obmc-armv7a-ast2600-toolchain-24.03-LTS.sh"
        self.run_command(f"sh {install_script} -d {install_path} -y")

class TaskClass(Task):
    def __init__(self, config, work_name=""):
        super(TaskClass, self).__init__(config, work_name)
        self.download_buildtools = DownloadDefaultBuildtools(config)
        self.custom_installer = CustomBuildToolsInstaller(config)
        self.use_custom_install = False
    
    def check_custom_install_config(self):
        """检查tools_install配置"""
        config = self.get_manufacture_config("tools_install/build_tool")
        if not config:
            return False
        label = config.get('label', 'default')
        return label != 'default'
    
    def run(self):
        if self.check_custom_install_config():
            self.custom_installer.run()  # 自定义安装
            self.use_custom_install = True
        else:
            self.download_buildtools.run()  # 默认安装
    
    def install(self):
        if self.use_custom_install:
            return  # 自定义安装已完成
        else:
            self.download_buildtools.install()

def run(self):
    """主执行函数"""
    try:
        # 1. 获取配置
        install_config = self.get_manufacture_config(self.config_key)
        if not install_config or install_config.get('label') == 'default':
            return  # 使用默认安装
        
        # 2. 验证配置
        self.validate_config(install_config)
        self.install_config = install_config
        
        # 3. 缓存验证
        if self.verify_install_cache():
            return  # 缓存有效，跳过安装
        
        # 4. 下载文件
        self.download_files()
        
        # 5. 安装文件
        self.install_downloaded_files()
        
        # 6. 生成安装标志
        self.generate_install_flag(success=True)
        
    except Exception as e:
        self.cleanup_on_failure()
        self.generate_install_flag(success=False, error_msg=str(e))
        raise errors.BmcGoException(f"安装失败: {str(e)}")

def verify_install_cache(self):
    """验证安装缓存是否有效"""
    # 1. 检查verify配置
    if not self.install_config.get('verify', False):
        return False
    
    # 2. 加载标志文件
    flag_data = self.load_install_flag()
    if not flag_data or not flag_data.get('success'):
        return False
    
    # 3. 计算当前文件哈希
    work_path = self.install_config.get('work_path')
    current_hash = self.calculate_directory_hash(work_path)
    
    # 4. 比对哈希值
    files_hash = flag_data.get('files_hash', {})
    for rel_path, expected_hash in files_hash.items():
        if current_hash.get(rel_path) != expected_hash:
            return False  # 文件变化，缓存失效
    
    return True  # 缓存有效

def sanitize_path(self, path):
    """路径安全检查"""
    path = os.path.expanduser(path)
    path = os.path.abspath(path)
    
    # 白名单检查：只允许操作安全目录
    allowed_paths = ['/opt', '/home', '/tmp', '/var/tmp']
    
    # 添加temp_path到允许列表
    if hasattr(self.config, 'temp_path'):
        allowed_paths.append(self.config.temp_path)
    
    if not any(path.startswith(allowed) for allowed in allowed_paths):
        raise errors.BmcGoException(f"路径{path}不在允许的目录范围内")

class CustomSDKInstaller(CustomInstaller):
    """SDK依赖安装器"""
    
    def __init__(self, config, work_name=""):
        super(CustomSDKInstaller, self).__init__(config, "sdk_tool", work_name)
    
    def execute_specified_install(self, install_path):
        """执行SDK特化安装逻辑"""
        work_path = self.install_config.get('work_path')
        # 默认使用复制模式
        if install_path:
            shutil.copytree(work_path, install_path)

class OeeBuildGppBin(BaseBuildGppBin):
    def __init__(self, config, work_name=""):
        super(OeeBuildGppBin, self).__init__(config, work_name=work_name)
        # 社区版本适配
        if misc.community_name() != "openubmc":
            self.suffix = "iBMC"
    
    def move_dependency(self):
        """OEE模式：移动OEE boot和内核文件"""
        self.info("OEE模式：跳过RTOS boot准备逻辑")
        self.chdir(self.config.hpm_build_dir)
        # 复制OEE boot文件
        self.run_command(f"cp -af {self.config.sdk_path}/u-boot-spl.bin ./")
        self.run_command(f"cp -af {self.config.sdk_path}/u-boot.bin ./")
        self.run_command(f"cp -af {self.config.sdk_path}/fitImage-obmc-phosphor-initramfs-evb-ast2600 ./kernel.bin")
        self.run_command(f"cp -af {self.config.work_out}/rootfs_{self.suffix}.img ./")
        self.run_command(f"cp -af {self.config.work_out}/rootfs_{self.suffix}.tar.gz ./")
    
    def build_gpp_hpm_bin(self):
        """OEE模式：构建MMC boot区"""
        self.info("OEE模式：构建OEE GPP二进制文件")
        # 创建2MB空白MMC boot区
        self.run_command(f"dd if=/dev/zero of=mmc-bootarea.img count=2 bs=1M")
        # 写入u-boot-spl（偏移0）
        self.run_command(f"dd if=u-boot-spl.bin of=mmc-bootarea.img conv=notrunc")
        # 写入u-boot（偏移64KB）
        self.run_command(f"dd if=u-boot.bin of=mmc-bootarea.img conv=notrunc seek=64 bs=1K")
        # HPM配置和头生成
        self.run_command(f"cp -af {self.config.board_path}/hpm_header.config ./")
        self.run_command("gpp_header hpm")
        self.write_gpp_bin()
    
    def write_gpp_bin(self):
        """OEE模式：打包OEE固件"""
        self.info(f"打包: {self.config.board_name}_gpp.bin")
        files = f"hpm_top_header mmc-bootarea.img kernel.bin rootfs_{self.suffix}.tar.gz"
        target_path = f"{self.config.work_out}/{self.config.board_name}_gpp.bin"
        cmd = f"cat {files}"
        self.pipe_command([cmd], target_path)

def create_gpp_builder(config, work_name=""):
    """工厂函数：根据chip类型选择GPP构建器"""
    if config.chip == "oee":
        return OeeBuildGppBin(config, work_name)
    else:
        return BaseBuildGppBin(config, work_name)

class TaskClass(Task):
    def __init__(self, config, work_name=""):
        super(TaskClass, self).__init__(config, work_name)
        self.gpp_builder = create_gpp_builder(config, work_name)
    
    def run(self):
        self.gpp_builder.run()

if misc.community_name() != "openubmc":
    self.suffix = "iBMC"  # iBMC社区版本
else:
    self.suffix = "BMC"   # openUBMC社区版本

class OeeBuildRootfsImg(BaseBuildRootfsImg):
    def __init__(self, config: Config, work_name=""):
        super(OeeBuildRootfsImg, self).__init__(config, work_name)
        # 社区版本适配
        if misc.community_name() != "openubmc":
            self.rootfs_img_path = f"{self.config.work_out}/rootfs_iBMC.img"
    
    def build_common_fs(self):
        """OEE模式：构建rootfs根文件系统"""
        self.chdir(self.buildimg_dir)
        self.info("开始构建 rootfs ...")
        
        # 解压OEE squashfs镜像
        oee_squashfs_path = os.path.join(self.config.sdk_path, 
            "obmc-phosphor-image-evb-ast2600-20260120133748.squashfs-xz")
        self.run_command(f"unsquashfs -f -d {self.rtos_rootfs} {oee_squashfs_path}", sudo=True)
        
        # 合并openubmc组件
        self.run_command("cp -af {}/. {}".format(self.config.rootfs_path, self.rtos_rootfs), sudo=True)
        
        # 拷贝升级dat文件
        self.copy_upgrade_dat_file()
        
        # 定制化处理
        for cus in self.customization:
            cus.rootfs_cust(self.rtos_rootfs)
        
        self.chdir(self.rtos_rootfs)
        self.strip()  # strip处理（继承）
        
        # 删除.a静态库（OEE特有）
        cmd = ["sudo find {} -type f -name *.a".format(self.rtos_rootfs), 
               "sudo xargs -P 0 -i{{}} rm {{}}"]
        self.pipe_command(cmd)
        
        self.build_cfg_fs()  # 构建cfgfs（继承）
    
    def make_rootfs_img(self):
        """OEE模式：制作rootfs镜像"""
        self.make_datafs_img()
        self.component_cust_conf()
        
        # 合并sr和soft sr，汇聚csr version
        csr_version = {}
        self.merge_sr_and_converge_version(csr_version)
        
        # 生成csr_version文件
        self.create_csr_version_file(csr_version)
        
        # 去除mds和sr文件中的空格和换行
        self.trim_mds_and_sr_json()
        
        self.component_swbom()
        self.run_command(f"sudo cp -a {self.rtos_rootfs}/. {self.mnt_datafs}/")
        self.rootfs_customization()
        
        self.chdir(self.config.work_out)
        self.create_global_properties_config_file()
        self.make_img()  # 制作镜像（继承，但不调用sign_ko）

def create_rootfs_builder(config: Config, work_name=""):
    """工厂函数：根据chip类型选择Rootfs构建器"""
    if config.chip == "oee":
        return OeeBuildRootfsImg(config, work_name)
    else:
        return BaseBuildRootfsImg(config, work_name)

class TaskClass(Task):
    def __init__(self, config: Config, work_name=""):
        super(TaskClass, self).__init__(config, work_name)
        self.rootfs_builder = create_rootfs_builder(config, work_name)
    
    def run(self):
        self.rootfs_builder.run()

def sign_ko(self):
    cfg = self.config.get_manufacture_config("base/signature/sign_ko", None)
    if cfg:
        self.warning("bingo工具不支持对ko文件签名，跳过此步骤！")

def make_img(self):
    self.sign_ko()  # 调用签名ko方法
    if self.config.chip == "1711":
        self.tools.make_img(self.rootfs_img_path, self.mnt_datafs, "376")
    else:
        self.tools.make_img(self.rootfs_img_path, self.mnt_datafs, "740")

def update_chip_info(self, platform_package):
    """根据rtos_version设置chip类型"""
    rtos_version = platform_package.get("options", {}).get("rtos_version", "rtos_v2")
    
    if rtos_version == "rtos_v2_1712":
        self.chip = "1712"
    if rtos_version == "oee":
        self.chip = "oee"
    # 默认为1711芯片（self.chip初始值）

def merge_dep_options(self):
    self.set_default_options()
    
    # OEE模式下跳过RTOS特有配置
    if self.config.chip != "oee":
        self.set_module_symver_options()  # 设置symver选项
        self.enable_1712_option()          # 启用1712芯片选项

def run(self):
    # OEE模式下直接返回，跳过RTOS裁剪
    if self.config.chip == "oee":
        return
    
    # RTOS裁剪流程
    self._prepare_env()
    self._download_rtos()
    self._install_rtos()
    self._merge_sdk()

def run(self):
    # OEE模式下跳过灵犀核构建（如果需要）
    if self.config.chip == "oee":
        # 可能跳过或调整灵犀核构建
        pass
    
    # 灵犀核构建流程
    ...